home *** CD-ROM | disk | FTP | other *** search
/ Champak 145 / (Vol 145) Dec 21 2011.iso / Games / Emo_Girly_Scene.swf / scripts / __Packages / mochi / as2 / MochiAd.as
Encoding:
Text File  |  2011-12-21  |  20.2 KB  |  669 lines
  1. class mochi.as2.MochiAd
  2. {
  3.    var clip;
  4.    var fadeout_start;
  5.    var fadeout_time;
  6.    var _parent;
  7.    var onEnterFrame;
  8.    var mc;
  9.    var started;
  10.    var _mochiad_bar;
  11.    var last_pcnt;
  12.    var server_control;
  13.    var fadeFunction;
  14.    var _mochiad_ctr;
  15.    var _url;
  16.    function MochiAd()
  17.    {
  18.    }
  19.    static function getVersion()
  20.    {
  21.       return "3.0 as2";
  22.    }
  23.    static function showPreGameAd(options)
  24.    {
  25.       var _loc26_ = {clip:_root,ad_timeout:3000,fadeout_time:250,regpt:"o",method:"showPreloaderAd",color:16747008,background:16777161,outline:13994812,no_progress_bar:false,ad_started:function()
  26.       {
  27.          this.clip.stop();
  28.       },ad_finished:function()
  29.       {
  30.          this.clip.play();
  31.       },ad_failed:function()
  32.       {
  33.          trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  34.       },ad_loaded:function(width, height)
  35.       {
  36.       },ad_skipped:function()
  37.       {
  38.       },ad_progress:function(percent)
  39.       {
  40.       }};
  41.       options = mochi.as2.MochiAd._parseOptions(options,_loc26_);
  42.       if("c862232051e0a94e1c3609b3916ddb17".substr(0) == "dfeada81ac97cde83665f81c12da7def")
  43.       {
  44.          options.ad_started();
  45.          options.ad_finished();
  46.          return undefined;
  47.       }
  48.       var clip = options.clip;
  49.       var _loc22_ = 11000;
  50.       var _loc25_ = options.ad_timeout;
  51.       delete options.ad_timeout;
  52.       var fadeout_time = options.fadeout_time;
  53.       delete options.fadeout_time;
  54.       if(!mochi.as2.MochiAd.load(options))
  55.       {
  56.          options.ad_failed();
  57.          options.ad_finished();
  58.          return undefined;
  59.       }
  60.       options.ad_started();
  61.       var mc = clip._mochiad;
  62.       mc.onUnload = function()
  63.       {
  64.          options.ad_finished();
  65.       };
  66.       var _loc14_ = mochi.as2.MochiAd._getRes(options);
  67.       var _loc4_ = _loc14_[0];
  68.       var _loc13_ = _loc14_[1];
  69.       mc._x = _loc4_ * 0.5;
  70.       mc._y = _loc13_ * 0.5;
  71.       var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  72.       chk._x = _loc4_ * -0.5;
  73.       chk._y = _loc13_ * -0.5;
  74.       var _loc6_ = chk.createEmptyMovieClip("_mochiad_bar",4);
  75.       if(options.no_progress_bar)
  76.       {
  77.          _loc6_._visible = false;
  78.          delete options.no_progress_bar;
  79.       }
  80.       else
  81.       {
  82.          _loc6_._x = 10;
  83.          _loc6_._y = _loc13_ - 20;
  84.       }
  85.       var _loc21_ = options.color;
  86.       delete options.color;
  87.       var _loc19_ = options.background;
  88.       delete options.background;
  89.       var _loc23_ = options.outline;
  90.       delete options.outline;
  91.       var _loc5_ = _loc6_.createEmptyMovieClip("_outline",1);
  92.       _loc5_.beginFill(_loc19_);
  93.       _loc5_.moveTo(0,0);
  94.       _loc5_.lineTo(_loc4_ - 20,0);
  95.       _loc5_.lineTo(_loc4_ - 20,10);
  96.       _loc5_.lineTo(0,10);
  97.       _loc5_.lineTo(0,0);
  98.       _loc5_.endFill();
  99.       var _loc3_ = _loc6_.createEmptyMovieClip("_inside",2);
  100.       _loc3_.beginFill(_loc21_);
  101.       _loc3_.moveTo(0,0);
  102.       _loc3_.lineTo(_loc4_ - 20,0);
  103.       _loc3_.lineTo(_loc4_ - 20,10);
  104.       _loc3_.lineTo(0,10);
  105.       _loc3_.lineTo(0,0);
  106.       _loc3_.endFill();
  107.       _loc3_._xscale = 0;
  108.       var _loc7_ = _loc6_.createEmptyMovieClip("_outline",3);
  109.       _loc7_.lineStyle(0,_loc23_,100);
  110.       _loc7_.moveTo(0,0);
  111.       _loc7_.lineTo(_loc4_ - 20,0);
  112.       _loc7_.lineTo(_loc4_ - 20,10);
  113.       _loc7_.lineTo(0,10);
  114.       _loc7_.lineTo(0,0);
  115.       chk.ad_msec = _loc22_;
  116.       chk.ad_timeout = _loc25_;
  117.       chk.started = getTimer();
  118.       chk.showing = false;
  119.       chk.last_pcnt = 0;
  120.       chk.fadeout_time = fadeout_time;
  121.       chk.fadeFunction = function()
  122.       {
  123.          var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  124.          if(_loc2_ > 0)
  125.          {
  126.             this._parent._alpha = _loc2_;
  127.          }
  128.          else
  129.          {
  130.             var _loc3_ = this._parent._parent;
  131.             mochi.as2.MochiAd.unload(_loc3_);
  132.             delete this.onEnterFrame;
  133.          }
  134.       };
  135.       mc.lc.regContLC = function(lc_name)
  136.       {
  137.          mc._containerLCName = lc_name;
  138.       };
  139.       var sendHostProgress = false;
  140.       mc.lc.sendHostLoadProgress = function(lc_name)
  141.       {
  142.          sendHostProgress = true;
  143.       };
  144.       mc.lc.adLoaded = options.ad_loaded;
  145.       mc.lc.adSkipped = options.ad_skipped;
  146.       mc.lc.adjustProgress = function(msec)
  147.       {
  148.          var _loc2_ = this.mc._mochiad_wait;
  149.          _loc2_.server_control = true;
  150.          _loc2_.started = getTimer();
  151.          _loc2_.ad_msec = msec;
  152.       };
  153.       mc.lc.rpc = function(callbackID, arg)
  154.       {
  155.          mochi.as2.MochiAd.rpc(clip,callbackID,arg);
  156.       };
  157.       mc.rpcTestFn = function(s)
  158.       {
  159.          trace("[MOCHIAD rpcTestFn] " + s);
  160.          return s;
  161.       };
  162.       chk.onEnterFrame = function()
  163.       {
  164.          var _loc6_ = this._parent._parent;
  165.          var _loc11_ = this._parent._mochiad_ctr;
  166.          var _loc5_ = getTimer() - this.started;
  167.          var _loc3_ = false;
  168.          var _loc4_ = _loc6_.getBytesTotal();
  169.          var _loc8_ = _loc6_.getBytesLoaded();
  170.          var _loc2_ = 100 * _loc8_ / _loc4_;
  171.          var _loc10_ = 100 * _loc5_ / chk.ad_msec;
  172.          var _loc9_ = this._mochiad_bar._inside;
  173.          var _loc13_ = Math.min(100,Math.min(_loc2_ || 0,_loc10_));
  174.          _loc13_ = Math.max(this.last_pcnt,_loc13_);
  175.          this.last_pcnt = _loc13_;
  176.          _loc9_._xscale = _loc13_;
  177.          options.ad_progress(_loc13_);
  178.          if(sendHostProgress)
  179.          {
  180.             clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{id:"hostLoadPcnt",pcnt:_loc2_});
  181.             if(_loc2_ == 100)
  182.             {
  183.                sendHostProgress = false;
  184.             }
  185.          }
  186.          if(!chk.showing)
  187.          {
  188.             var _loc7_ = _loc11_.getBytesTotal();
  189.             if(_loc7_ > 0 || typeof _loc7_ == "undefined")
  190.             {
  191.                chk.showing = true;
  192.                chk.started = getTimer();
  193.             }
  194.             else if(_loc5_ > chk.ad_timeout && _loc2_ == 100)
  195.             {
  196.                options.ad_failed();
  197.                _loc3_ = true;
  198.             }
  199.          }
  200.          if(_loc5_ > chk.ad_msec)
  201.          {
  202.             _loc3_ = true;
  203.          }
  204.          if(_loc4_ > 0 && _loc8_ >= _loc4_ && _loc3_)
  205.          {
  206.             if(this.server_control)
  207.             {
  208.                delete this.onEnterFrame;
  209.             }
  210.             else
  211.             {
  212.                this.fadeout_start = getTimer();
  213.                this.onEnterFrame = chk.fadeFunction;
  214.             }
  215.          }
  216.       };
  217.    }
  218.    static function showClickAwayAd(options)
  219.    {
  220.       var _loc9_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showClickAwayAd",res:"300x250",no_bg:true,ad_started:function()
  221.       {
  222.       },ad_finished:function()
  223.       {
  224.       },ad_loaded:function(width, height)
  225.       {
  226.       },ad_failed:function()
  227.       {
  228.          trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  229.       },ad_skipped:function()
  230.       {
  231.       }};
  232.       options = mochi.as2.MochiAd._parseOptions(options,_loc9_);
  233.       var clip = options.clip;
  234.       var _loc8_ = options.ad_timeout;
  235.       delete options.ad_timeout;
  236.       if(!mochi.as2.MochiAd.load(options))
  237.       {
  238.          options.ad_failed();
  239.          options.ad_finished();
  240.          return undefined;
  241.       }
  242.       options.ad_started();
  243.       var mc = clip._mochiad;
  244.       mc.onUnload = function()
  245.       {
  246.          options.ad_finished();
  247.       };
  248.       var _loc4_ = mochi.as2.MochiAd._getRes(options);
  249.       var _loc10_ = _loc4_[0];
  250.       var _loc7_ = _loc4_[1];
  251.       mc._x = _loc10_ * 0.5;
  252.       mc._y = _loc7_ * 0.5;
  253.       var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  254.       chk.ad_timeout = _loc8_;
  255.       chk.started = getTimer();
  256.       chk.showing = false;
  257.       mc.lc.adLoaded = options.ad_loaded;
  258.       mc.lc.adSkipped = options.ad_skipped;
  259.       mc.lc.rpc = function(callbackID, arg)
  260.       {
  261.          mochi.as2.MochiAd.rpc(clip,callbackID,arg);
  262.       };
  263.       mc.rpcTestFn = function(s)
  264.       {
  265.          trace("[MOCHIAD rpcTestFn] " + s);
  266.          return s;
  267.       };
  268.       var _loc20_ = false;
  269.       mc.lc.regContLC = function(lc_name)
  270.       {
  271.          mc._containerLCName = lc_name;
  272.       };
  273.       chk.onEnterFrame = function()
  274.       {
  275.          var _loc5_ = this._parent._mochiad_ctr;
  276.          var _loc4_ = getTimer() - this.started;
  277.          var _loc2_ = false;
  278.          if(!chk.showing)
  279.          {
  280.             var _loc3_ = _loc5_.getBytesTotal();
  281.             if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  282.             {
  283.                _loc2_ = true;
  284.                chk.showing = true;
  285.                chk.started = getTimer();
  286.             }
  287.             else if(_loc4_ > chk.ad_timeout)
  288.             {
  289.                options.ad_failed();
  290.                _loc2_ = true;
  291.             }
  292.          }
  293.          if(_loc2_)
  294.          {
  295.             delete this.onEnterFrame;
  296.          }
  297.       };
  298.    }
  299.    static function showInterLevelAd(options)
  300.    {
  301.       var _loc13_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showTimedAd",ad_started:function()
  302.       {
  303.          this.clip.stop();
  304.       },ad_finished:function()
  305.       {
  306.          this.clip.play();
  307.       },ad_failed:function()
  308.       {
  309.          trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  310.       },ad_loaded:function(width, height)
  311.       {
  312.       },ad_skipped:function()
  313.       {
  314.       }};
  315.       options = mochi.as2.MochiAd._parseOptions(options,_loc13_);
  316.       var clip = options.clip;
  317.       var _loc10_ = 11000;
  318.       var _loc12_ = options.ad_timeout;
  319.       delete options.ad_timeout;
  320.       var fadeout_time = options.fadeout_time;
  321.       delete options.fadeout_time;
  322.       if(!mochi.as2.MochiAd.load(options))
  323.       {
  324.          options.ad_failed();
  325.          options.ad_finished();
  326.          return undefined;
  327.       }
  328.       options.ad_started();
  329.       var mc = clip._mochiad;
  330.       mc.onUnload = function()
  331.       {
  332.          options.ad_finished();
  333.       };
  334.       var _loc5_ = mochi.as2.MochiAd._getRes(options);
  335.       var _loc14_ = _loc5_[0];
  336.       var _loc11_ = _loc5_[1];
  337.       mc._x = _loc14_ * 0.5;
  338.       mc._y = _loc11_ * 0.5;
  339.       var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  340.       chk.ad_msec = _loc10_;
  341.       chk.ad_timeout = _loc12_;
  342.       chk.started = getTimer();
  343.       chk.showing = false;
  344.       chk.fadeout_time = fadeout_time;
  345.       chk.fadeFunction = function()
  346.       {
  347.          var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  348.          if(_loc2_ > 0)
  349.          {
  350.             this._parent._alpha = _loc2_;
  351.          }
  352.          else
  353.          {
  354.             var _loc3_ = this._parent._parent;
  355.             mochi.as2.MochiAd.unload(_loc3_);
  356.             delete this.onEnterFrame;
  357.          }
  358.       };
  359.       mc.lc.adLoaded = options.ad_loaded;
  360.       mc.lc.adSkipped = options.ad_skipped;
  361.       mc.lc.adjustProgress = function(msec)
  362.       {
  363.          var _loc2_ = this.mc._mochiad_wait;
  364.          _loc2_.server_control = true;
  365.          _loc2_.started = getTimer();
  366.          _loc2_.ad_msec = msec - 250;
  367.       };
  368.       mc.lc.rpc = function(callbackID, arg)
  369.       {
  370.          mochi.as2.MochiAd.rpc(clip,callbackID,arg);
  371.       };
  372.       mc.rpcTestFn = function(s)
  373.       {
  374.          trace("[MOCHIAD rpcTestFn] " + s);
  375.          return s;
  376.       };
  377.       chk.onEnterFrame = function()
  378.       {
  379.          var _loc5_ = this._parent._mochiad_ctr;
  380.          var _loc4_ = getTimer() - this.started;
  381.          var _loc2_ = false;
  382.          if(!chk.showing)
  383.          {
  384.             var _loc3_ = _loc5_.getBytesTotal();
  385.             if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  386.             {
  387.                chk.showing = true;
  388.                chk.started = getTimer();
  389.             }
  390.             else if(_loc4_ > chk.ad_timeout)
  391.             {
  392.                options.ad_failed();
  393.                _loc2_ = true;
  394.             }
  395.          }
  396.          if(_loc4_ > chk.ad_msec)
  397.          {
  398.             _loc2_ = true;
  399.          }
  400.          if(_loc2_)
  401.          {
  402.             if(this.server_control)
  403.             {
  404.                delete this.onEnterFrame;
  405.             }
  406.             else
  407.             {
  408.                this.fadeout_start = getTimer();
  409.                this.onEnterFrame = this.fadeFunction;
  410.             }
  411.          }
  412.       };
  413.    }
  414.    static function showPreloaderAd(options)
  415.    {
  416.       trace("[MochiAd] DEPRECATED: showPreloaderAd was renamed to showPreGameAd in 2.0");
  417.       mochi.as2.MochiAd.showPreGameAd(options);
  418.    }
  419.    static function showTimedAd(options)
  420.    {
  421.       trace("[MochiAd] DEPRECATED: showTimedAd was renamed to showInterLevelAd in 2.0");
  422.       mochi.as2.MochiAd.showInterLevelAd(options);
  423.    }
  424.    static function _allowDomains(server)
  425.    {
  426.       var _loc1_ = server.split("/")[2].split(":")[0];
  427.       if(System.security)
  428.       {
  429.          if(System.security.allowDomain)
  430.          {
  431.             System.security.allowDomain("*");
  432.             System.security.allowDomain(_loc1_);
  433.          }
  434.          if(System.security.allowInsecureDomain)
  435.          {
  436.             System.security.allowInsecureDomain("*");
  437.             System.security.allowInsecureDomain(_loc1_);
  438.          }
  439.       }
  440.       return _loc1_;
  441.    }
  442.    static function load(options)
  443.    {
  444.       var _loc13_ = {clip:_root,server:"http://x.mochiads.com/srv/1/",method:"load",depth:10333,id:"_UNKNOWN_"};
  445.       options = mochi.as2.MochiAd._parseOptions(options,_loc13_);
  446.       options.swfv = options.clip.getSWFVersion() || 6;
  447.       options.mav = mochi.as2.MochiAd.getVersion();
  448.       var _loc7_ = options.clip;
  449.       if(!mochi.as2.MochiAd._isNetworkAvailable())
  450.       {
  451.          return null;
  452.       }
  453.       if(_loc7_._mochiad_loaded)
  454.       {
  455.          return null;
  456.       }
  457.       var _loc12_ = options.depth;
  458.       delete options.depth;
  459.       var _loc6_ = _loc7_.createEmptyMovieClip("_mochiad",_loc12_);
  460.       var _loc11_ = mochi.as2.MochiAd._getRes(options);
  461.       options.res = _loc11_[0] + "x" + _loc11_[1];
  462.       options.server += options.id;
  463.       delete options.id;
  464.       _loc7_._mochiad_loaded = true;
  465.       if(_loc7_._url.indexOf("http") != 0)
  466.       {
  467.          trace("[MochiAd] NOTE: Security Sandbox Violation errors below are normal");
  468.       }
  469.       var _loc4_ = _loc6_.createEmptyMovieClip("_mochiad_ctr",1);
  470.       for(var _loc8_ in options)
  471.       {
  472.          _loc4_[_loc8_] = options[_loc8_];
  473.       }
  474.       var _loc10_ = _loc4_.server;
  475.       delete _loc4_.server;
  476.       var _loc14_ = mochi.as2.MochiAd._allowDomains(_loc10_);
  477.       _loc6_.onEnterFrame = function()
  478.       {
  479.          if(this._mochiad_ctr._url != this._url)
  480.          {
  481.             this.onEnterFrame = function()
  482.             {
  483.                if(!this._mochiad_ctr)
  484.                {
  485.                   delete this.onEnterFrame;
  486.                   mochi.as2.MochiAd.unload(this._parent);
  487.                }
  488.             };
  489.          }
  490.       };
  491.       var _loc5_ = new LocalConnection();
  492.       var _loc9_ = ["",Math.floor(new Date().getTime()),random(999999)].join("_");
  493.       _loc5_.mc = _loc6_;
  494.       _loc5_.name = _loc9_;
  495.       _loc5_.hostname = _loc14_;
  496.       _loc5_.allowDomain = function(d)
  497.       {
  498.          return true;
  499.       };
  500.       _loc5_.allowInsecureDomain = _loc5_.allowDomain;
  501.       _loc5_.connect(_loc9_);
  502.       _loc6_.lc = _loc5_;
  503.       _loc4_.lc = _loc9_;
  504.       _loc4_.st = getTimer();
  505.       _loc4_.loadMovie(_loc10_ + ".swf","POST");
  506.       return _loc6_;
  507.    }
  508.    static function unload(clip)
  509.    {
  510.       if(typeof clip == "undefined")
  511.       {
  512.          clip = _root;
  513.       }
  514.       if(clip.clip && clip.clip._mochiad)
  515.       {
  516.          clip = clip.clip;
  517.       }
  518.       if(!clip._mochiad)
  519.       {
  520.          return false;
  521.       }
  522.       if(clip._mochiad._containerLCName != undefined)
  523.       {
  524.          clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{id:"unload"});
  525.       }
  526.       clip._mochiad.removeMovieClip();
  527.       delete clip._mochiad_loaded;
  528.       delete clip._mochiad;
  529.       return true;
  530.    }
  531.    static function _isNetworkAvailable()
  532.    {
  533.       if(System.security)
  534.       {
  535.          var _loc1_ = System.security;
  536.          if(_loc1_.sandboxType == "localWithFile")
  537.          {
  538.             return false;
  539.          }
  540.       }
  541.       return true;
  542.    }
  543.    static function _getRes(options)
  544.    {
  545.       var _loc3_ = options.clip.getBounds();
  546.       var _loc2_ = 0;
  547.       var _loc1_ = 0;
  548.       if(typeof options.res != "undefined")
  549.       {
  550.          var _loc4_ = options.res.split("x");
  551.          _loc2_ = parseFloat(_loc4_[0]);
  552.          _loc1_ = parseFloat(_loc4_[1]);
  553.       }
  554.       else
  555.       {
  556.          _loc2_ = _loc3_.xMax - _loc3_.xMin;
  557.          _loc1_ = _loc3_.yMax - _loc3_.yMin;
  558.       }
  559.       if(_loc2_ == 0 || _loc1_ == 0)
  560.       {
  561.          _loc2_ = Stage.width;
  562.          _loc1_ = Stage.height;
  563.       }
  564.       return [_loc2_,_loc1_];
  565.    }
  566.    static function _parseOptions(options, defaults)
  567.    {
  568.       var _loc4_ = {};
  569.       for(var _loc8_ in defaults)
  570.       {
  571.          _loc4_[_loc8_] = defaults[_loc8_];
  572.       }
  573.       if(options)
  574.       {
  575.          for(_loc8_ in options)
  576.          {
  577.             _loc4_[_loc8_] = options[_loc8_];
  578.          }
  579.       }
  580.       if(_root.mochiad_options)
  581.       {
  582.          var _loc5_ = _root.mochiad_options.split("&");
  583.          var _loc2_ = 0;
  584.          while(_loc2_ < _loc5_.length)
  585.          {
  586.             var _loc3_ = _loc5_[_loc2_].split("=");
  587.             _loc4_[unescape(_loc3_[0])] = unescape(_loc3_[1]);
  588.             _loc2_ = _loc2_ + 1;
  589.          }
  590.       }
  591.       if(_loc4_.id == "test")
  592.       {
  593.          trace("[MochiAd] WARNING: Using the MochiAds test identifier, make sure to use the code from your dashboard, not this example!");
  594.       }
  595.       return _loc4_;
  596.    }
  597.    static function rpc(clip, callbackID, arg)
  598.    {
  599.       switch(arg.id)
  600.       {
  601.          case "setValue":
  602.             mochi.as2.MochiAd.setValue(clip,arg.objectName,arg.value);
  603.             break;
  604.          case "getValue":
  605.             var _loc4_ = mochi.as2.MochiAd.getValue(clip,arg.objectName);
  606.             clip._mochiad.lc.send(clip._mochiad._containerLCName,"rpcResult",callbackID,_loc4_);
  607.             break;
  608.          case "runMethod":
  609.             var _loc3_ = mochi.as2.MochiAd.runMethod(clip,arg.method,arg.args);
  610.             clip._mochiad.lc.send(clip._mochiad._containerLCName,"rpcResult",callbackID,_loc3_);
  611.             break;
  612.          default:
  613.             trace("[mochiads rpc] unknown rpc id: " + arg.id);
  614.       }
  615.    }
  616.    static function setValue(base, objectName, value)
  617.    {
  618.       var _loc2_ = objectName.split(".");
  619.       var _loc1_ = undefined;
  620.       _loc1_ = 0;
  621.       while(_loc1_ < _loc2_.length - 1)
  622.       {
  623.          if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  624.          {
  625.             return undefined;
  626.          }
  627.          base = base[_loc2_[_loc1_]];
  628.          _loc1_ = _loc1_ + 1;
  629.       }
  630.       base[_loc2_[_loc1_]] = value;
  631.    }
  632.    static function getValue(base, objectName)
  633.    {
  634.       var _loc2_ = objectName.split(".");
  635.       var _loc1_ = undefined;
  636.       _loc1_ = 0;
  637.       while(_loc1_ < _loc2_.length - 1)
  638.       {
  639.          if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  640.          {
  641.             return undefined;
  642.          }
  643.          base = base[_loc2_[_loc1_]];
  644.          _loc1_ = _loc1_ + 1;
  645.       }
  646.       return base[_loc2_[_loc1_]];
  647.    }
  648.    static function runMethod(base, methodName, argsArray)
  649.    {
  650.       var _loc2_ = methodName.split(".");
  651.       var _loc1_ = undefined;
  652.       _loc1_ = 0;
  653.       while(_loc1_ < _loc2_.length - 1)
  654.       {
  655.          if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  656.          {
  657.             return undefined;
  658.          }
  659.          base = base[_loc2_[_loc1_]];
  660.          _loc1_ = _loc1_ + 1;
  661.       }
  662.       if(typeof base[_loc2_[_loc1_]] == "function")
  663.       {
  664.          return base[_loc2_[_loc1_]].apply(base,argsArray);
  665.       }
  666.       return undefined;
  667.    }
  668. }
  669.